package com.iot.inter.controller.newinterface.sync;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.iot.inter.entity.newpojo.Constant;
import com.iot.inter.entity.newpojo.response.subResponse.SyncPackagesResponse;
import com.iot.inter.entity.newpojo.response.subResponse.common.Page;
import com.iot.inter.entity.newpojo.response.subResponse.common._Package;
import com.iot.inter.entity.newrequest.sync.syncpackages.request.RequestSyncPackages;
import com.iot.inter.entity.newrequest.sync.syncpackages.response.ResponseSyncPackageList;
import com.iot.inter.entity.newrequest.sync.syncpackages.response.ResponseSyncPackages;
import com.iot.inter.interfaceprocessing.newinterface.TrunToSyncService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.log4j.Logger;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

/**
 * 去北京做：3.1	同步资费套餐：2.0接口
 * <p>
 * 该接口用于设备接入方获取其可以使用的资费套餐信息，资费套餐包括两种：
 * 	日程套餐；
 * 	流量套餐；
 * 关于流量套餐，其使用规则如下：
 * 	订购周期单位有如下几种：天、月、季度（即3个月）、半年（即6个月）、一年（即12个月）；
 * 	存在两种类型的流量套餐：
 * 	预付费套餐：允许使用加油包，但是订购周期是固定的，且不允许续订；
 * 	后付费套餐：不允许使用加油包，订购周期为N倍的订购周期单位，允许续订；
 * 	流量使用规则定义如下：
 * 	规定了允许在单位订购周期内可使用的最大流量，单位为M字节；
 * 	如果单位订购周期内流量使用完毕，且没有订购加油包，则直接停机；若订购加油了，则启动加油包流量；加油包流量在本单位订购周期结束日期；
 * 	在单位订购周期结束后，如果订单尚未结束，则启动新的单位订购周期，周期内流量从0开始计算；
 * 	按【天】的流量套餐，订购周期单位以天计算；
 * 	按【月】的流量套餐，单位订购周期以自然月计算；
 * 	按【季度】的流量套餐，单位订购周期为3个自然月；
 * 	按【半年】的流量套餐，单位订购周期为6个自然月；
 * 	按【年】的流量套餐，单位订购周期为12个自然月；
 * 	对于月流量套餐订单，如果订单在10号以后启动（不包括10号），订购周期+1；
 * 	对于季度流量套餐订单，如果订单在10号以后启动（不包括10号），对于预付费套餐，则订购时长为4个自然月；对于后付费套餐，则订购周期中的第一个季度为4个自然月，其他为3个自然月；
 * 	对于半年流量套餐订单，如果订单在10号以后启动（不包括10号），对于预付费套餐，则订购时长为7个自然月；对于后付费套餐，则订购周期中的第一个半年为7个自然月，其他为6个自然月；
 * 	对于年流量套餐订单，如果订单在10号以后启动（不包括10号），对于预付费套餐，则订购时长为13个自然月；对于后付费套餐，则订购周期中的第一个半年为13个自然月，其他为12个自然月；
 * 	加油包：使用规则如下：
 * 	加油包不可直接被订购，要依附于关联的流量套餐，被设备订购；
 * 	仅允许订购预付费套餐的订单订购加油包；
 * 	加油包仅设定其允许设备使用的最大流量；
 * 	加油包的有效期为当前套餐订单的有效期；
 * 关于日程套餐，其使用规则如下：
 * 	所有流量都是事先预装好的。
 * 	设定了两种定价方式：单天定价、打包定价；
 * 	对于单天定价的日程套餐，允许订购上限天数和下限天数不一致，上限天数允许不做设置；
 * 	对于打包定价要求订购上下限天数必须相同；
 *
 * @author lm
 * @date 2019/8/29
 */
@RestController
@Api(description = "3.1 同步资费套餐")
public class SyncPackagesController {
    private static Logger logger = Logger.getLogger(SyncPackagesController.class);

    /**
     * 考虑到该接入方使用的资费套餐可能有很多，所以每次同步时，都采用分页的方式，每次仅同步给接入方一页的资费套餐信息，
     * 每页包含的资费套餐信息个数由接入方自行定义。
     * 如果接入方想获取所有资费套餐信息，并且存在多页套餐信息的话，接入方需要多次调用同步资费套餐接口。
     *
     * @author lm
     * @date 2019/8/26
     */

    @CrossOrigin
    @RequestMapping(value = "syncPackages", produces = "application/json;charset=utf-8", method = RequestMethod.POST)
    @ResponseBody
    @ApiOperation(value = "3.1 同步资费套餐", response = ResponseSyncPackages.class)
    public String syncPackages(@ApiParam @RequestBody RequestSyncPackages request) {
        //3,定义要回复的内容
        String jsonString;
        String requestStr = JSON.toJSONString(request);
        if (requestStr != null) {

            logger.info("【同步资费套餐】请求：" + requestStr);
            RequestSyncPackages requestPackage = JSONArray.parseObject(requestStr, RequestSyncPackages.class);
            Integer pageNo = requestPackage.getPageNo();
            Integer pageSize = requestPackage.getPageSize();
            String partnerCode = requestPackage.getPartnerCode();
            String secret = requestPackage.getSecret();

            TrunToSyncService sync = new TrunToSyncService();
            SyncPackagesResponse response = sync.syncPackages(pageNo, pageSize, partnerCode, secret);

            if (response != null) {
                if (true == Constant.RET_CODE_0000.equalsIgnoreCase(response.getRetCode())) {

                    List<ResponseSyncPackageList> tradeDataList = new ArrayList<ResponseSyncPackageList>();
                    Page page = null;
                    if (response.getBody() != null) {

                        ResponseSyncPackageList tradeData = null;

                        if (response.getBody().get_package() != null) {

                            for (_Package p : response.getBody().get_package()) {

                                tradeData = new ResponseSyncPackageList();

                                tradeData.setPackageType(p.getPackageType());
                                tradeData.setPackageCode(p.getPackageCode());
                                tradeData.setPackageName(p.getPackageName());
                                tradeData.setPacakgeNameEn(p.getPacakgeNameEn());
                                tradeData.setPackageDesc(p.getPackageDesc());
                                tradeData.setBuyType(p.getBuyType());
                                tradeData.setPriceType(p.getPriceType());
                                tradeData.setPackageFlow(p.getPackageFlow());
                                tradeData.setCoverCountrys(p.getCoverCountrys());
                                tradeData.setCoverCountryMcc(p.getCoverCountryMcc());
                                tradeData.setMinOrderPeriod(p.getMinOrderPeriod());
                                tradeData.setMaxOrderPeriod(p.getMaxOrderPeriod());
                                tradeData.setStatus(p.getStatus());
                                tradeData.setCostPrice(p.getCostPrice());
                                tradeData.setPackage_usage_attribute(p.getPackage_usage_attribute());

                                tradeDataList.add(tradeData);

                            }

                            page = new Page();
                            page.setCurrentPageNo(response.getBody().getPage().getCurrentPageNo());
                            page.setPageSize(response.getBody().getPage().getPageSize());
                            page.setTotalCount(response.getBody().getPage().getTotalCount());
                            page.setTotalPages(response.getBody().getPage().getTotalPages());
                        }

                    }


                    ResponseSyncPackages responseOrder = new ResponseSyncPackages();
                    responseOrder.setRetCode(response.getRetCode());
                    responseOrder.setResultInfo(response.getResultInfo());
                    responseOrder.setTradeData(tradeDataList);
                    responseOrder.setPackageNum(response.getBody().getPackageNum());
                    responseOrder.setPage(page);
                    jsonString = JSON.toJSONString(responseOrder);
                    logger.info("【同步资费套餐】成功响应：" + jsonString);
                    return jsonString;


                } else {

                    ResponseSyncPackages responseOrder = new ResponseSyncPackages();
                    responseOrder.setRetCode(response.getRetCode());
                    responseOrder.setResultInfo(response.getResultInfo());
                    jsonString = JSON.toJSONString(responseOrder);
                    logger.info("【同步资费套餐】响应：" + jsonString);
                    return jsonString;
                }


            } else {
                ResponseSyncPackages responseOrder = new ResponseSyncPackages();
                responseOrder.setRetCode("9998");
                responseOrder.setResultInfo("响应报文为空");
                jsonString = JSON.toJSONString(responseOrder);
                logger.info("【同步资费套餐】响应：" + jsonString);
                return jsonString;
            }

        } else {
            ResponseSyncPackages responseOrder = new ResponseSyncPackages();
            responseOrder.setRetCode("9998");
            responseOrder.setResultInfo("请求报文为空");
            jsonString = JSON.toJSONString(responseOrder);
            logger.info("【同步资费套餐】响应：" + jsonString);
            return jsonString;


        }

    }

}
